import { isTauri } from './secure-storage';

/**
 * 打开文件选择对话框
 * @param accept 文件类型过滤（例如：'image/*' 或 'all files'）
 * @param multiple 是否支持多选（默认 false）
 * @returns 选择的文件路径（单个）或路径数组（多个）或 null
 */
export const openFileDialog = async (accept: string = '*/*', multiple: boolean = false): Promise<string | string[] | null> => {
  if (isTauri()) {
    try {
      const { open } = await import('@tauri-apps/plugin-dialog');
      
      // 配置选项
      const openOptions: any = {
        multiple: multiple,
        directory: false, // 明确设置为 false，确保只能选择文件，不能选择目录
      };

      if (accept.startsWith('image/')) {
        // 图片选择
        openOptions.filters = [{
          name: '图片',
          extensions: ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'svg']
        }];
      } else {
        // 通用文件选择
        // 根据 accept 参数设置过滤器
        if (accept === '*/*') {
          // 所有文件：不设置 filters，让系统显示所有文件
          // 或者提供一个"所有文件"选项，但不限制扩展名
          // 在某些系统上，不设置 filters 可能更好
          // 但为了更好的兼容性，我们提供一个包含常见类型的过滤器
          openOptions.filters = [
            {
              name: '所有文件',
              extensions: [] // 空数组在 Tauri 中表示所有文件类型
            }
          ];
        } else if (accept.includes('image')) {
          openOptions.filters = [{ name: '图片', extensions: ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'svg'] }];
        } else if (accept.includes('video')) {
          openOptions.filters = [{ name: '视频', extensions: ['mp4', 'avi', 'mov', 'wmv', 'flv', 'mkv', 'webm'] }];
        } else if (accept.includes('audio')) {
          openOptions.filters = [{ name: '音频', extensions: ['mp3', 'wav', 'flac', 'aac', 'ogg', 'm4a'] }];
        } else if (accept.includes('pdf')) {
          openOptions.filters = [{ name: 'PDF', extensions: ['pdf'] }];
        } else {
          // 默认：所有文件
          openOptions.filters = [
            {
              name: '所有文件',
              extensions: [] // 空数组在 Tauri 中表示所有文件类型
            }
          ];
        }
      }
      
      const selected = await open(openOptions);
      
      if (selected) {
        if (Array.isArray(selected)) {
          // 多选返回数组
          return selected;
        } else if (typeof selected === 'string') {
          // 单选返回字符串
          return selected;
        }
      }
      return null;
    } catch (error) {
      console.error('Tauri 文件选择失败:', error);
      throw error;
    }
  } else {
    // 浏览器环境，使用 HTML input
    return new Promise((resolve) => {
      try {
        const input = document.createElement('input');
        input.type = 'file';
        input.accept = accept;
        input.style.display = 'none';
        document.body.appendChild(input);
        
        input.addEventListener('change', () => {
          try {
            // 直接使用 input 元素，而不是 event.target
            if (input && input.files && input.files.length > 0) {
              // 在浏览器环境中，我们需要使用 File 对象，但这里返回 null 让调用者使用 HTML input
              resolve(null);
            } else {
              resolve(null);
            }
          } catch (error) {
            console.error('处理文件选择事件失败:', error);
            resolve(null);
          } finally {
            if (document.body.contains(input)) {
              document.body.removeChild(input);
            }
          }
        });
        
        input.addEventListener('cancel', () => {
          resolve(null);
          if (document.body.contains(input)) {
            document.body.removeChild(input);
          }
        });
        
        input.click();
      } catch (error) {
        console.error('创建文件输入失败:', error);
        resolve(null);
      }
    });
  }
};

/**
 * 将文件路径数组转换为 File 对象数组（仅 Tauri 环境）
 */
export const pathsToFiles = async (filePaths: string[]): Promise<File[]> => {
  if (!isTauri()) {
    return [];
  }
  
  const files: File[] = [];
  for (const filePath of filePaths) {
    const file = await pathToFile(filePath);
    if (file) {
      files.push(file);
    }
  }
  return files;
};

/**
 * 将文件路径转换为 File 对象（仅 Tauri 环境）
 */
export const pathToFile = async (filePath: string): Promise<File | null> => {
  if (!isTauri()) {
    return null;
  }
  
  try {
    const { readFile } = await import('@tauri-apps/plugin-fs');
    
    // 读取文件内容
    const fileData = await readFile(filePath);
    
    // 获取文件名（从路径中提取）
    const pathParts = filePath.split(/[/\\]/);
    const fileName = pathParts[pathParts.length - 1] || 'file';
    
    // 根据文件扩展名确定 MIME 类型
    const getMimeType = (filename: string): string => {
      const ext = filename.split('.').pop()?.toLowerCase();
      const mimeTypes: Record<string, string> = {
        'jpg': 'image/jpeg',
        'jpeg': 'image/jpeg',
        'png': 'image/png',
        'gif': 'image/gif',
        'webp': 'image/webp',
        'bmp': 'image/bmp',
        'svg': 'image/svg+xml',
        'pdf': 'application/pdf',
        'doc': 'application/msword',
        'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
        'xls': 'application/vnd.ms-excel',
        'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
        'zip': 'application/zip',
        'txt': 'text/plain',
        'mp3': 'audio/mpeg',
        'mp4': 'video/mp4',
      };
      return mimeTypes[ext || ''] || 'application/octet-stream';
    };
    
    // 创建 Blob 并转换为 File
    const mimeType = getMimeType(fileName);
    const blob = new Blob([fileData], { type: mimeType });
    const file = new File([blob], fileName, {
      type: mimeType,
    });
    
    return file;
  } catch (error) {
    console.error('读取文件失败:', error);
    return null;
  }
};

